#include<iostream>
#include<cstring>
#include<iomanip>
using namespace std;

const int MAXN = 105;
const long long INF = 0x3f3f3f3f;

long long r[MAXN][MAXN];    // 距离
long long d[MAXN][MAXN];    // 最短路径数量
long long path[MAXN][MAXN][MAXN];  // 经过k的路径数量
double ans[MAXN];

int main(){
    int n,e;
    cin>>n>>e;
    
    // 初始化
    memset(r, 0x3f, sizeof(r));
    memset(d, 0, sizeof(d));
    memset(path, 0, sizeof(path));
    
    // 读入边
    for(int i=1;i<=e;i++){
        int x,y,z;
        cin>>x>>y>>z;
        r[x][y]=z;
        r[y][x]=z;
    }
    
    // 初始化直接相连的点之间的路径数为1
    for(int i=1;i<=n;i++){
        r[i][i]=0;  // 自己到自己的距离为0
        for(int j=1;j<=n;j++){
            if(r[i][j]!=INF && i!=j) d[i][j]=1;
        }
    }
    
    // Floyd更新最短路和路径数
    for(int k=1;k<=n;k++){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(r[i][k]!=INF && r[k][j]!=INF){
                    if(r[i][k]+r[k][j]<r[i][j]){
                        r[i][j]=r[i][k]+r[k][j];
                        d[i][j]=d[i][k]*d[k][j];
                    }
                    else if(r[i][k]+r[k][j]==r[i][j]){
                        d[i][j]+=d[i][k]*d[k][j];
                    }
                }
            }
        }
    }
    
    // 计算经过每个点k的最短路径数量
    for(int k=1;k<=n;k++){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(i!=j && i!=k && j!=k && r[i][k]!=INF && r[k][j]!=INF){
                    if(r[i][k]+r[k][j]==r[i][j]){
                        path[i][j][k]=d[i][k]*d[k][j];
                    }
                }
            }
        }
    }
    
    // 计算每个点的影响力
    for(int k=1;k<=n;k++){
        ans[k]=0;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(i!=j && i!=k && j!=k){
                    if(r[i][j]!=INF && d[i][j]>0){
                        ans[k]+=1.0*r[i][j]/d[i][j]*path[i][j][k];
                    }
                }
            }
        }
    }
    // 输出结果
    for(int i=1;i<=n;i++){
        cout<<fixed<<setprecision(3)<<ans[i]<<endl;
    }
    return 0;
}
//计算路径，d[i][k]*d[k][j]//i到k，k到[j]
//更新路径长度同时更新数量
//相等则相加。
//自己到自己为0直接相连路径为1